Figure 2 v3

library(Matrix)
library(igraph)

Attaching package: 'igraph'

The following objects are masked from 'package:stats':

    decompose, spectrum

The following object is masked from 'package:base':

    union

library(data.table)
library(doParallel)

Loading required package: foreach

Loading required package: iterators

Loading required package: parallel

set.seed(42)

allSig <- fread("~/Code/tissue_biomarker/biomarker_res/allSigBio.csv")
gene_info <- fread("~/Code/tissue_biomarker/geneInfo.csv")

gene_info[, V1 := gsub(V1, pat = "\\.[0-9]+$", rep = "")]

gene_symbol <- gene_info[, .(V1, gene_name)]

colnames(gene_symbol)[1] <- "Gene"

drugTargetInfo <- fread("~/Code/Github/pachyderm/Annotations/DrugTargetCompilation_updated.csv")


drugTargetInfo <- drugTargetInfo[BHKLAB.DRUGID %in% allSig$Drug]

drugTargetInfo <- drugTargetInfo[, .("TARGET" = unique(TARGET_NAME)), BHKLAB.DRUGID]

drugTargetInfo <- drugTargetInfo[complete.cases(drugTargetInfo), ]

drugTargetInfo <- drugTargetInfo[drugTargetInfo$TARGET %in% gene_info$gene_name, ]

drugTargetInfo[, TARGET := gene_info$V1[match(TARGET, gene_info$gene_name)]]

2a

Loading in Reactome Pathway and creating a network.

reactomeBottom <- fread("~/Code/tissue_biomarker/pathways/ReactomeBottom.txt")
reactomeBottom <- reactomeBottom[V6 == "Homo sapiens"]
reactomeBottom <- reactomeBottom[grepl(x = V1, pat = "ENSG")]


reactomeGenes <- unique(reactomeBottom[[1]])


reactomeMatrix <- matrix(0, nrow = length(reactomeGenes), ncol = length(reactomeGenes))

colnames(reactomeMatrix) <- rownames(reactomeMatrix) <- reactomeGenes


reactomeBottomPathways <- split(reactomeBottom, by = "V4")


for (pathway in reactomeBottomPathways) {
    reactomeMatrix[pathway[[1]], pathway[[1]]] <- 1
}

reactomeGraph <- graph_from_adjacency_matrix(reactomeMatrix, weighted = "1", mode = "undirected")

I think 3 comparisons are in order: Target to random gene, Random Gene to Biomarker, and Random Gene to Random

First, lets identify the distances between markers and targets.

reactomeDist <- distances(reactomeGraph)

distance.list <- list()
random_to_targets.list <- list()
random_to_random.list <- list()

for (drug in drugTargetInfo[, unique(BHKLAB.DRUGID)]) {
    targets <- drugTargetInfo[BHKLAB.DRUGID == drug, TARGET]

    markers <- allSig[Drug == drug, Gene]

    tg <- unique(na.omit(match(targets, colnames(reactomeMatrix))))

    mk <- unique(na.omit(match(markers, colnames(reactomeMatrix))))

    num_targets <- length(tg)
    num_markers <- length(mk)

    mk_random <- sample(length(vertex.attributes(reactomeGraph)$name), num_markers)
    tg_random <- sample(length(vertex.attributes(reactomeGraph)$name), num_targets)

    if(!length(tg)||!length(mk)) next
    distance.list[[drug]] <- distances(reactomeGraph, tg, mk)
    random_to_targets.list[[drug]] <- distances(reactomeGraph, tg, mk_random)
    random_to_random.list[[drug]] <- distances(reactomeGraph, tg_random, mk_random)
}

Now we take the minimum distance from each marker (real or random) to each target (real or random).

distance.list.min <- lapply(distance.list, \(x) return(apply(x, 2, min)))
random_to_random.list.min <- lapply(random_to_random.list, \(x) return(apply(x, 2, min)))
random_to_targets.list.min <- lapply(random_to_targets.list, \(x) return(apply(x, 2, min)))

distance.list.m <- rbindlist(lapply(names(distance.list.min), \(nm){
    return(data.frame(Drug = nm, Gene = names(distance.list.min[[nm]]), Distance = distance.list.min[[nm]]))
}))


random_to_random.list.m <- rbindlist(lapply(names(random_to_random.list.min), \(nm){
    return(data.frame(Drug = nm, Gene = names(random_to_random.list.min[[nm]]), Distance = random_to_random.list.min[[nm]]))
}))

random_to_targets.list.m <- rbindlist(lapply(names(random_to_targets.list.min), \(nm){
    return(data.frame(Drug = nm, Gene = names(random_to_targets.list.min[[nm]]), Distance = random_to_targets.list.min[[nm]]))
}))

Lets Plot.

distance.list.m[,Cat := "Biomarker to Target"]

random_to_random.list.m[, Cat := "Random to Random"]

random_to_targets.list.m[, Cat := "Random to Target"]

toPlot <- rbindlist(list(distance.list.m, random_to_random.list.m, random_to_targets.list.m))
toPlot[, weight := 1 / .N, Cat]

toPlot$Distance <- factor(toPlot$Distance)

library(ggplot2)

ggplot(toPlot, aes(x = Distance, weight = weight)) +
    geom_bar() +
    facet_grid(rows = vars(Cat)) +
    theme_bw() +
    theme(legend.position = "None")

toPlot[, weight := 1 / .N, Cat]

pdf("figures/reactomeNetworkMinDistanceDist.pdf", height = 4, width = 3)
ggplot(toPlot, aes(x = Distance, weight = weight)) +
    geom_bar() +
    facet_grid(rows = vars(Cat)) +
    theme_bw() +
    theme(legend.position = "None")

dev.off()

png 
  2 

# ggplot(toPlot, aes(x = Distance, fill = Cat, weight = weight)) +
#     geom_bar() +
#     facet_grid(rows = vars(Cat)) +
#     theme_bw()

# ggplot(toPlot, aes(x = Distance, fill = Cat, weight = weight)) +
#     geom_bar(position=position_identity(), alpha=0.6) +
#     theme_bw()

toPlot2 <- toPlot[, .(Proportion = sum(weight)), .(Cat, Distance)][order(Proportion, decreasing = TRUE)]

ggplot(toPlot2, aes(x = Distance, y = Proportion, fill = Cat)) +
    geom_col(position = position_identity(), alpha = 0.6) +
    theme_bw() +
    theme(legend.position = c(0.75, 0.8))

pdf("figures/reactomeNetworkMinDistanceDistOverlapping.pdf", height = 4, width = 4)
ggplot(toPlot2, aes(x = Distance, y = Proportion, fill = Cat)) +
    geom_col(position = position_identity(), alpha = 0.6) +
    theme_bw() +
    theme(legend.position = c(0.75, 0.8))

dev.off()

png 
  2 

toPlot$Cat <- factor(toPlot$Cat, levels = c("Biomarker to Target", "Random to Target", "Random to Random"))

ggplot(toPlot, aes(x = Distance, weight = weight, fill = Cat)) +
    geom_bar(position = "dodge") +
    ylab("Proportion") +
    theme_bw() +
    theme(legend.position = c(0.75, 0.8), legend.title = element_blank()) + scale_fill_brewer(palette = "Set2")

pdf("figures/reactomeNetworkMinDistanceDistDodge.pdf", height = 4, width = 4)
ggplot(toPlot, aes(x = Distance, weight = weight, fill = Cat)) +
    geom_bar(position = "dodge") +
    ylab("Proportion") +
    theme_bw() +
    theme(legend.position = c(0.75, 0.8), legend.title = element_blank()) + scale_fill_brewer(palette = "Set2")

dev.off()

png 
  2 

Lets print out the statistics as well:

mean(reactomeDist[is.finite(reactomeDist)])

[1] 2.900658

toPlot$Distance <- as.numeric(as.character(toPlot$Distance))

my.split <- split(toPlot$Distance, f = toPlot$Cat)

wilcox.test(my.split[["Biomarker to Target"]],
            my.split[["Random to Target"]])

    Wilcoxon rank sum test with continuity correction

data:  my.split[["Biomarker to Target"]] and my.split[["Random to Target"]]
W = 3585156, p-value = 5.107e-14
alternative hypothesis: true location shift is not equal to 0

wilcox.test(
    my.split[["Random to Target"]],
    my.split[["Random to Random"]]
)

    Wilcoxon rank sum test with continuity correction

data:  my.split[["Random to Target"]] and my.split[["Random to Random"]]
W = 4275996, p-value = 1.887e-07
alternative hypothesis: true location shift is not equal to 0

wilcox.test(
    my.split[["Biomarker to Target"]],
    my.split[["Random to Random"]]
)

    Wilcoxon rank sum test with continuity correction

data:  my.split[["Biomarker to Target"]] and my.split[["Random to Random"]]
W = 3890058, p-value = 0.06468
alternative hypothesis: true location shift is not equal to 0

2b

allRes <- fread("~/Code/tissue_biomarker/rnaResults/biomarker_res/meta_res_pharmacodb.csv")
allSig <- allRes[BF_p_all < 0.05]
allSig[, Is_Target := "No"]

allSig[!Drug %in% drugTargetInfo$BHKLAB.DRUGID, Is_Target := "No Target Info"]

allSig[, Target_Pathway_Distance := ifelse(Gene %in% colnames(distance.list[[Drug]]), min(distance.list[[Drug]][, Gene]), NA_real_), .(Drug, Gene)]

allSig[drugTargetInfo, Is_Target := "Yes", on = c("Drug" = "BHKLAB.DRUGID", Gene = "TARGET")]

pdf("figures/abs_estimate_vs_distance_to_target.pdf", height = 3, width = 4)
ggplot(allSig, 
    aes(factor(Target_Pathway_Distance, exclude=c(NA_real_,Inf)), y=abs(estimate)))+geom_boxplot() + 
theme_bw()+  xlab("Distance to Drug Target") + ylab("Absolute Correlation\nwith Drug Response")

dev.off()

png 
  2 

toTest <- copy(allSig)

toTest$Target_Pathway_Distance <- factor(toTest$Target_Pathway_Distance, exclude = c(NA_real_, Inf))
toTest$estimate <- abs(toTest$estimate)

kruskal.test(estimate ~ Target_Pathway_Distance, toTest)

    Kruskal-Wallis rank sum test

data:  estimate by Target_Pathway_Distance
Kruskal-Wallis chi-squared = 28.882, df = 5, p-value = 2.446e-05

wilcox.test(toTest[Target_Pathway_Distance == 0,estimate], toTest[Target_Pathway_Distance!=0, estimate])

    Wilcoxon rank sum test with continuity correction

data:  toTest[Target_Pathway_Distance == 0, estimate] and toTest[Target_Pathway_Distance != 0, estimate]
W = 19113, p-value = 0.04391
alternative hypothesis: true location shift is not equal to 0

wilcox.test(toTest[Target_Pathway_Distance == 5, estimate], toTest[Target_Pathway_Distance != 5, estimate])

    Wilcoxon rank sum test with continuity correction

data:  toTest[Target_Pathway_Distance == 5, estimate] and toTest[Target_Pathway_Distance != 5, estimate]
W = 1760, p-value = 0.08164
alternative hypothesis: true location shift is not equal to 0

2b.5

TODO: Fix the rest of this document!!

TODO:: for all documents, look at improvement over a drug matched null

We want to see whether being closer to the drug target in the Reactome network makes you more likely to pass meta-analysis. This means we need to redo the distance between biomarker and target analysis for allRes, instead of just allSig.

drugTargetInfoAll <- fread("~/Code/Github/pachyderm/Annotations/DrugTargetCompilation_updated.csv")


drugTargetInfoAll <- drugTargetInfoAll[BHKLAB.DRUGID %in% allRes$Drug]

drugTargetInfoAll <- drugTargetInfoAll[, .("TARGET" = unique(TARGET_NAME)), BHKLAB.DRUGID]

drugTargetInfoAll <- drugTargetInfoAll[complete.cases(drugTargetInfoAll), ]

drugTargetInfoAll <- drugTargetInfoAll[drugTargetInfoAll$TARGET %in% gene_info$gene_name, ]

drugTargetInfoAll[, TARGET := gene_info$V1[match(TARGET, gene_info$gene_name)]]

distance.list.all <- list()



for (drug in drugTargetInfoAll[, unique(BHKLAB.DRUGID)]) {
    targets <- drugTargetInfoAll[BHKLAB.DRUGID == drug, TARGET]

    markers <- allRes[Drug == drug, Gene]

    tg <- unique(na.omit(match(targets, colnames(reactomeMatrix))))

    mk <- unique(na.omit(match(markers, colnames(reactomeMatrix))))

    distance.list.all[[drug]] <- reactomeDist[tg, mk, drop = FALSE]
}

min.distance.list.all <- lapply(distance.list.all, \(x) {
    apply(x, 2, min)
})

min.distance.list.all.m <- rbindlist(lapply(names(min.distance.list.all), \(nm){return(data.frame(Drug=nm, Gene = names(min.distance.list.all[[nm]]), Distance=min.distance.list.all[[nm]]))}))

min.distance.list.all.m[, `Meta Analysis` := "Not Significant"]

min.distance.list.all.m[allSig, `Meta Analysis` := "Significant", on = c("Drug", "Gene")]

min.distance.list.all.m[, weight := 1 / .N, `Meta Analysis`]

mean(min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance][is.finite(min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance])])

[1] 2.201417

mean(min.distance.list.all.m[`Meta Analysis` == "Significant", Distance][is.finite(min.distance.list.all.m[`Meta Analysis` == "Significant", Distance])])

[1] 2.231843

wilcox.test(
    min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance],
    min.distance.list.all.m[`Meta Analysis` == "Significant", Distance]
)

    Wilcoxon rank sum test with continuity correction

data:  min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance] and min.distance.list.all.m[`Meta Analysis` == "Significant", Distance]
W = 3186310, p-value = 0.2385
alternative hypothesis: true location shift is not equal to 0

# Checking to confirm the direction of the trend
wilcox.test(
    min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance],
    min.distance.list.all.m[`Meta Analysis` == "Significant", Distance],
    alternative = "l"
)

    Wilcoxon rank sum test with continuity correction

data:  min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance] and min.distance.list.all.m[`Meta Analysis` == "Significant", Distance]
W = 3186310, p-value = 0.1193
alternative hypothesis: true location shift is less than 0

mean(min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance][is.finite(min.distance.list.all.m[`Meta Analysis` == "Not Significant", Distance])])

[1] 2.201417

mean(min.distance.list.all.m[`Meta Analysis` == "Significant", Distance][is.finite(min.distance.list.all.m[`Meta Analysis` == "Significant", Distance])])

[1] 2.231843

ggplot(min.distance.list.all.m, aes(Distance, fill = `Meta Analysis`, weight = weight)) +
    geom_bar(position = "dodge") +
    theme_bw() +
    scale_fill_brewer(palette = "Paired") +
    ylab("Proportion")

Warning: Removed 65 rows containing non-finite values (stat_count).

    theme(legend.position = c(0.75, 0.8))

List of 1
 $ legend.position: num [1:2] 0.75 0.8
 - attr(*, "class")= chr [1:2] "theme" "gg"
 - attr(*, "complete")= logi FALSE
 - attr(*, "validate")= logi TRUE

pdf("figures/reactomeNetworkMinDistanceByMetaAnalysisDodge.pdf", height = 4, width = 4)
ggplot(min.distance.list.all.m, aes(Distance, fill = `Meta Analysis`, weight = weight)) +
    geom_bar(position = "dodge") +
    theme_bw() +
    scale_fill_brewer(palette = "Paired") +
    ylab("Proportion")  +
    theme(legend.position = c(0.75, 0.8))

Warning: Removed 65 rows containing non-finite values (stat_count).

dev.off()

png 
  2 

The mean number of targets per drug is similar between the two groups, so I am not too worried about bias from taking the min.

distance.list.all.m <- rbindlist(lapply(distance.list.all, reshape2::melt), idcol = "Drug")
colnames(distance.list.all.m) <- c("Drug", "Target", "Gene", "Distance")
distance.list.all.m[, `Meta Analysis` := "Not Significant"]

distance.list.all.m[allSig, `Meta Analysis` := "Significant", on = c("Drug", "Gene")]

distance.list.all.m[, length(unique(Target)) / length(unique(Drug)), `Meta Analysis`]

2c

Loading results from CRISPR and RNAi. Here, we are going to calculate whether biomarkers which correlated with a drug target are closer to that specific drug target. For later results, they are independent of particular drug target, so later we will treat correlation with any target equally.

crispr.res <- readRDS("~/Code/tissue_biomarker/depmap/crispr_biomarker_res_allmarkers.rds")
rnai.res <- readRDS("~/Code/tissue_biomarker/depmap/rnai_biomarker_res_allmarkers.rds")


drugTargetInfoAll <- fread("~/Code/Github/pachyderm/Annotations/DrugTargetCompilation_updated.csv")


drugTargetInfoAll <- drugTargetInfoAll[BHKLAB.DRUGID %in% allRes$Drug]

drugTargetInfoAll <- drugTargetInfoAll[, .("TARGET" = unique(TARGET_NAME)), BHKLAB.DRUGID]

drugTargetInfoAll <- drugTargetInfoAll[complete.cases(drugTargetInfoAll), ]

drugTargetInfoAll <- drugTargetInfoAll[drugTargetInfoAll$TARGET %in% gene_info$gene_name, ]

drugTargetInfoAll[, ENSG := gene_info$V1[match(TARGET, gene_info$gene_name)]]

crispr.res.m <- lapply(crispr.res, \(x){

    tbl <- data.table(reshape2::melt(x[,,"significant",drop=FALSE]))
    tbl <- tbl[,-3]
    colnames(tbl) <- c("Gene", "Target", "Significant")
    tbl
})

Loading required package: PharmacoGx

Loading required package: CoreGx

Loading required package: BiocGenerics

Attaching package: 'BiocGenerics'

The following objects are masked from 'package:igraph':

    normalize, path, union

The following objects are masked from 'package:stats':

    IQR, mad, sd, var, xtabs

The following objects are masked from 'package:base':

    anyDuplicated, append, as.data.frame, basename, cbind, colnames,
    dirname, do.call, duplicated, eval, evalq, Filter, Find, get, grep,
    grepl, intersect, is.unsorted, lapply, Map, mapply, match, mget,
    order, paste, pmax, pmax.int, pmin, pmin.int, Position, rank,
    rbind, Reduce, rownames, sapply, setdiff, sort, table, tapply,
    union, unique, unsplit, which.max, which.min

Loading required package: SummarizedExperiment

Loading required package: MatrixGenerics

Loading required package: matrixStats

Attaching package: 'MatrixGenerics'

The following objects are masked from 'package:matrixStats':

    colAlls, colAnyNAs, colAnys, colAvgsPerRowSet, colCollapse,
    colCounts, colCummaxs, colCummins, colCumprods, colCumsums,
    colDiffs, colIQRDiffs, colIQRs, colLogSumExps, colMadDiffs,
    colMads, colMaxs, colMeans2, colMedians, colMins, colOrderStats,
    colProds, colQuantiles, colRanges, colRanks, colSdDiffs, colSds,
    colSums2, colTabulates, colVarDiffs, colVars, colWeightedMads,
    colWeightedMeans, colWeightedMedians, colWeightedSds,
    colWeightedVars, rowAlls, rowAnyNAs, rowAnys, rowAvgsPerColSet,
    rowCollapse, rowCounts, rowCummaxs, rowCummins, rowCumprods,
    rowCumsums, rowDiffs, rowIQRDiffs, rowIQRs, rowLogSumExps,
    rowMadDiffs, rowMads, rowMaxs, rowMeans2, rowMedians, rowMins,
    rowOrderStats, rowProds, rowQuantiles, rowRanges, rowRanks,
    rowSdDiffs, rowSds, rowSums2, rowTabulates, rowVarDiffs, rowVars,
    rowWeightedMads, rowWeightedMeans, rowWeightedMedians,
    rowWeightedSds, rowWeightedVars

Loading required package: GenomicRanges

Loading required package: stats4

Loading required package: S4Vectors

Attaching package: 'S4Vectors'

The following objects are masked from 'package:data.table':

    first, second

The following objects are masked from 'package:Matrix':

    expand, unname

The following objects are masked from 'package:base':

    expand.grid, I, unname

Loading required package: IRanges

Attaching package: 'IRanges'

The following object is masked from 'package:data.table':

    shift

Loading required package: GenomeInfoDb

Loading required package: Biobase

Welcome to Bioconductor

    Vignettes contain introductory material; view with
    'browseVignettes()'. To cite Bioconductor, see
    'citation("Biobase")', and for packages 'citation("pkgname")'.

Attaching package: 'Biobase'

The following object is masked from 'package:MatrixGenerics':

    rowMedians

The following objects are masked from 'package:matrixStats':

    anyMissing, rowMedians

Attaching package: 'PharmacoGx'

The following objects are masked from 'package:CoreGx':

    .parseToRoxygen, amcc, connectivityScore, cosinePerm, gwc, mcc

crispr.res.m <- lapply(names(crispr.res.m), function(nm) {
    xx <- strsplit(nm, split = "_")[[1]]

    tissue <- xx[1]
    drug <- xx[2]
    tbl <- crispr.res.m[[nm]]
    tbl[,Drug := drug]
    tbl[,Tissue := tissue]
    tbl
})

crispr.res.m <- rbindlist(crispr.res.m)

crispr.res.m[, Gene := gsub(pat = "\\.[0-9]+", rep = "", x = Gene)]

crispr.res.m[, Target := trimws(gsub(pat = "\\([0-9]+\\)", rep = "", x = Target))]

crispr.res.m[, TargetENSG := gene_info$V1[match(Target, gene_info$gene_name)]]

crispr.res.m[, Distance := ifelse(Gene %in% colnames(reactomeDist) & TargetENSG %in% colnames(reactomeDist), reactomeDist[TargetENSG, Gene], NA_real_), .(Gene, TargetENSG)]

crispr.res.m <- crispr.res.m[complete.cases(crispr.res.m)]

crispr.res.m[, `CRISPR Sig` := ifelse(Significant == 1, "Associated\nwith CRISPR", "Not Associated")]

# filter to only those that pass meta-analysis
crispr.res.m <- crispr.res.m[allSig, , on = c("Gene", "Tissue", "Drug"), nomatch = 0]

crispr.res.m[, weight := 1 / .N, Significant]

wilcox.test(split(crispr.res.m, by = "CRISPR Sig")[[1]][, Distance], split(crispr.res.m, by = "CRISPR Sig")[[2]][, Distance])

    Wilcoxon rank sum test with continuity correction

data:  split(crispr.res.m, by = "CRISPR Sig")[[1]][, Distance] and split(crispr.res.m, by = "CRISPR Sig")[[2]][, Distance]
W = 1312296, p-value = 0.8252
alternative hypothesis: true location shift is not equal to 0

colPal <- c("#fb9a99", "#e31a1c")

crispr.res.m$Distance <- factor(crispr.res.m$Distance)

ggplot(
    crispr.res.m,
    aes(Distance, weight = weight, fill = `CRISPR Sig`)
) +
    geom_bar(position = "dodge") +
    theme_bw() +
    xlab("Distance to Drug Target") +
    ylab("Proportion") +
    scale_fill_manual(values = colPal) +
    theme(legend.position = c(0.75, 0.8), legend.title = element_blank())

pdf("figures/reactomeNetworkDistanceToTargetCRISPR.pdf", height = 4, width = 4)
ggplot(
    crispr.res.m,
    aes(Distance, weight = weight, fill = `CRISPR Sig`)
) +
    geom_bar(position = "dodge") +
    theme_bw() +
    xlab("Distance to Drug Target") +
    ylab("Proportion") +
    scale_fill_manual(values = colPal) +
    theme(legend.position = c(0.75, 0.8), legend.title = element_blank())

dev.off()

png 
  2 

rnai.res.m <- lapply(rnai.res, \(x){
    tbl <- data.table(reshape2::melt(x[, , "significant", drop = FALSE]))
    tbl <- tbl[, -3]
    colnames(tbl) <- c("Gene", "Target", "Significant")
    tbl
})



rnai.res.m <- lapply(names(rnai.res.m), function(nm) {
    xx <- strsplit(nm, split = "_")[[1]]

    tissue <- xx[1]
    drug <- xx[2]
    tbl <- rnai.res.m[[nm]]
    tbl[, Drug := drug]
    tbl[, Tissue := tissue]
    tbl
})

rnai.res.m <- rbindlist(rnai.res.m)

rnai.res.m[, Gene := gsub(pat = "\\.[0-9]+", rep = "", x = Gene)]

rnai.res.m[, Target := trimws(gsub(pat = "\\([0-9]+\\)", rep = "", x = Target))]

rnai.res.m[, TargetENSG := gene_info$V1[match(Target, gene_info$gene_name)]]

rnai.res.m[, Distance := ifelse(Gene %in% colnames(reactomeDist) & TargetENSG %in% colnames(reactomeDist), reactomeDist[TargetENSG, Gene], NA_real_), .(Gene, TargetENSG)]

rnai.res.m <- rnai.res.m[complete.cases(rnai.res.m)]

rnai.res.m[, `RNAi Sig` := ifelse(Significant == 1, "Associated\nwith RNAi", "Not Associated")]

# filter to only those that pass meta-analysis
rnai.res.m <- rnai.res.m[allSig, , on = c("Gene", "Tissue", "Drug"), nomatch = 0]

rnai.res.m[, weight := 1 / .N, Significant]

wilcox.test(split(rnai.res.m, by="RNAi Sig")[[1]][,Distance], split(rnai.res.m, by="RNAi Sig")[[2]][,Distance])

    Wilcoxon rank sum test with continuity correction

data:  split(rnai.res.m, by = "RNAi Sig")[[1]][, Distance] and split(rnai.res.m, by = "RNAi Sig")[[2]][, Distance]
W = 3353992, p-value = 0.5308
alternative hypothesis: true location shift is not equal to 0

colPal <- c("#b2df8a","#33a02c")

rnai.res.m$Distance <- factor(rnai.res.m$Distance)

ggplot(
    rnai.res.m,
    aes(Distance, weight = weight, fill = `RNAi Sig`)
) +
    geom_bar(position = "dodge") +
    theme_bw() +
    xlab("Distance to Drug Target") +
    ylab("Proportion") +
    scale_fill_manual(values = colPal)+
        theme(legend.position = c(0.75, 0.8), legend.title = element_blank())

pdf("figures/reactomeNetworkDistanceToTargetRNAi.pdf", height = 4, width = 4)
ggplot(
    rnai.res.m,
    aes(Distance, weight = weight, fill = `RNAi Sig`)
) +
    geom_bar(position = "dodge") +
    theme_bw() +
    xlab("Distance to Drug Target") +
    ylab("Proportion") +
    scale_fill_manual(values = colPal) +
    theme(legend.position = c(0.75, 0.8), legend.title = element_blank())

dev.off()

png 
  2 

crispr.cor.with.target <- sapply(crispr.res, function(x) apply(x[, , "significant", drop = F], 1, any, na.rm = T))

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

crispr.cor.with.target <- lapply(names(crispr.cor.with.target), function(nm) {
    xx <- strsplit(nm, split = "_")[[1]]

    tissue <- xx[1]
    drug <- xx[2]

    data.frame(
        Tissue = tissue, Drug = drug, Gene = names(crispr.cor.with.target[[nm]]),
        status = crispr.cor.with.target[[nm]]
    )
})


crispr.cor.with.target <- rbindlist(crispr.cor.with.target)



rnai.cor.with.target <- sapply(rnai.res, function(x) apply(x[, , "significant", drop = F], 1, any, na.rm = T))

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

Warning in FUN(array(newX[, i], d.call, dn.call), ...): coercing argument of
type 'double' to logical

rnai.cor.with.target <- lapply(names(rnai.cor.with.target), function(nm) {
    xx <- strsplit(nm, split = "_")[[1]]

    tissue <- xx[1]
    drug <- xx[2]

    data.frame(
        Tissue = tissue, Drug = drug, Gene = names(rnai.cor.with.target[[nm]]),
        status = rnai.cor.with.target[[nm]]
    )
})


rnai.cor.with.target <- rbindlist(rnai.cor.with.target)

rnai.cor.with.target[, Gene := gsub(pat = "\\.[0-9]+", rep = "", x = Gene)]

crispr.cor.with.target[, Gene := gsub(pat = "\\.[0-9]+", rep = "", x = Gene)]

rnai.merged <- allRes[rnai.cor.with.target, , on = .(Tissue, Drug, Gene)]


allSig[, RNAi := "Not Associated"]

allSig[, CRISPR := "Not Associated"]

allSig[rnai.cor.with.target[(status)], RNAi := "Associated\nwith RNAi", on = .(Drug, Gene, Tissue)]

allSig[crispr.cor.with.target[(status)], CRISPR := "Associated\nwith CRISPR", on = .(Drug, Gene, Tissue)]

prop.table(table(allSig$RNAi))

Associated\nwith RNAi        Not Associated 
            0.1454587             0.8545413 

prop.table(table(allSig$CRISPR))

Associated\nwith CRISPR          Not Associated 
             0.05670816              0.94329184 

2d

pdf("figures/CRISPR_boxplot_effect_size.pdf", height = 3, width = 3)
ggplot(
    allSig,
    aes(CRISPR, abs(estimate))
) +
    geom_boxplot() +
    theme_bw() +
    xlab("") +
    ylab("Absolute Correlation\nwith Drug Response")

dev.off()

png 
  2 

ggplot(
    allSig,
    aes(CRISPR, abs(estimate))
) +
    geom_boxplot() +
    theme_bw() +
    xlab("") +
    ylab("Absolute Correlation\nwith Drug Response")

ggplot(
    allSig,
    aes(CRISPR, abs(estimate))
) +
    geom_violin(fill = "gray70") +
    geom_boxplot(width = 0.3) +
    theme_bw() +
    ylab("Absolute Correlation\nwith Drug Response") +
    theme(legend.position = c(0.85, 0.85)) + xlab("")

pdf("figures/CRISPR_violin_effect_size.pdf", height = 3, width = 3)
ggplot(
    allSig,
    aes(CRISPR, abs(estimate))
) +
    geom_violin(fill = "gray70") +
    geom_boxplot(width = 0.3) +
    theme_bw() +
    ylab("Absolute Correlation\nwith Drug Response") + xlab("")

dev.off()

png 
  2 

pdf("figures/RNAi_boxplot_effect_size.pdf", height = 3, width = 3)
ggplot(
    allSig,
    aes(RNAi, abs(estimate))
) +
    geom_boxplot() +
    theme_bw() +
    xlab("") +
    ylab("Absolute Correlation\nwith Drug Response")

dev.off()

png 
  2 

ggplot(
    allSig,
    aes(RNAi, abs(estimate))
) +
    geom_boxplot() +
    theme_bw() +
    xlab("") +
    ylab("Absolute Correlation\nwith Drug Response")

ggplot(
    allSig,
    aes(RNAi, abs(estimate))
) +
    geom_violin(fill = "gray70") + geom_boxplot(width=0.3) +
    theme_bw() +
    ylab("Absolute Correlation\nwith Drug Response") + 
    theme(legend.position = c(0.85, 0.85)) + xlab("")

pdf("figures/RNAi_violin_effect_size.pdf", height = 3, width = 3)
ggplot(
    allSig,
    aes(RNAi, abs(estimate))
) +
    geom_violin(fill = "gray70") +
    geom_boxplot(width = 0.3) +
    theme_bw() +
    ylab("Absolute Correlation\nwith Drug Response") + xlab("")

dev.off()

png 
  2 

wilcox.test(split(allSig[, abs(estimate)], allSig$RNAi)[[1]], split(allSig[, abs(estimate)], allSig$RNAi)[[2]])

    Wilcoxon rank sum test with continuity correction

data:  split(allSig[, abs(estimate)], allSig$RNAi)[[1]] and split(allSig[, abs(estimate)], allSig$RNAi)[[2]]
W = 964173, p-value = 1.639e-12
alternative hypothesis: true location shift is not equal to 0

wilcox.test(split(allSig[, abs(estimate)], allSig$CRISPR)[[1]], split(allSig[, abs(estimate)], allSig$CRISPR)[[2]])

    Wilcoxon rank sum test with continuity correction

data:  split(allSig[, abs(estimate)], allSig$CRISPR)[[1]] and split(allSig[, abs(estimate)], allSig$CRISPR)[[2]]
W = 594536, p-value = 1.741e-06
alternative hypothesis: true location shift is not equal to 0

2f

allRes[, RNAi := "Not Associated"]

allRes[, CRISPR := "Not Associated"]

allRes[rnai.cor.with.target[(status)], RNAi := "Associated\nwith RNAi", on = .(Drug, Gene, Tissue)]

allRes[crispr.cor.with.target[(status)], CRISPR := "Associated\nwith CRISPR", on = .(Drug, Gene, Tissue)]

allRes[,`Passes Meta-Analysis` := "No"]

allRes[BF_p_all<=0.05,`Passes Meta-Analysis`:="Yes"]

allRes[, table(`Passes Meta-Analysis`, RNAi)]

                    RNAi
Passes Meta-Analysis Associated\nwith RNAi Not Associated
                 No                    484           2979
                 Yes                   631           3707

allRes[, table(`Passes Meta-Analysis`, CRISPR)]

                    CRISPR
Passes Meta-Analysis Associated\nwith CRISPR Not Associated
                 No                      311           3152
                 Yes                     246           4092

fisher.test(allRes[, table(`Passes Meta-Analysis`, RNAi)][, c(2, 1)])

    Fisher's Exact Test for Count Data

data:  allRes[, table(`Passes Meta-Analysis`, RNAi)][, c(2, 1)]
p-value = 0.4942
alternative hypothesis: true odds ratio is not equal to 1
95 percent confidence interval:
 0.9201632 1.1933453
sample estimates:
odds ratio 
  1.047694 

fisher.test(allRes[, table(`Passes Meta-Analysis`, CRISPR)][, c(2, 1)])

    Fisher's Exact Test for Count Data

data:  allRes[, table(`Passes Meta-Analysis`, CRISPR)][, c(2, 1)]
p-value = 2.184e-08
alternative hypothesis: true odds ratio is not equal to 1
95 percent confidence interval:
 0.5100145 0.7273963
sample estimates:
odds ratio 
 0.6093432